
package main.old.new_2023.last.month_11;


import java.util.*;

/**
 * @Description: todo 53. 最大子数组和
 * 给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
 * 子数组 是数组中的一个连续部分。
 *
 * todo 2342. 数位和相等数对的最大和
 * 你一个下标从 0 开始的数组 nums ，数组中的元素都是 正 整数。请你选出两个下标 i 和 j（i != j），且 nums[i] 的数位和 与  nums[j] 的数位和相等。
 * 请你找出所有满足条件的下标 i 和 j ，找出并返回 nums[i] + nums[j] 可以得到的 最大值 。
 *
 * todo 2760. 最长奇偶子数组
 * 给你一个下标从 0 开始的整数数组 nums 和一个整数 threshold 。
 * 请你从 nums 的子数组中找出以下标 l 开头、下标 r 结尾 (0 <= l <= r < nums.length) 且满足以下条件的 最长子数组 ：
 * nums[l] % 2 == 0
 * 对于范围 [l, r - 1] 内的所有下标 i ，nums[i] % 2 != nums[i + 1] % 2
 * 对于范围 [l, r] 内的所有下标 i ，nums[i] <= threshold
 * 以整数形式返回满足题目要求的最长子数组的长度。
 * 注意：子数组 是数组中的一个连续非空元素序列。
 *
 * todo 2656. K 个元素的最大和
 * 给你一个下标从 0 开始的整数数组 nums 和一个整数 k 。你需要执行以下操作 恰好 k 次，最大化你的得分：
 * 从 nums 中选择一个元素 m 。
 * 将选中的元素 m 从数组中删除。
 * 将新元素 m + 1 添加到数组中。
 * 你的得分增加 m 。
 * 请你返回执行以上操作恰好 k 次后的最大得分。
 *
 * @Author: Take-off
 * @Date: 1:00 PM 2023/6/
 * @Param:
 * @return:
 **/
public class Solution1120 {

    //K 个元素的最大和
    public int maximizeSum(int[] nums, int k) {
        int m = Arrays.stream(nums).max().getAsInt();
        return (2 * m + k - 1) * k / 2;

    }

    //最长奇偶子数组
    public int longestAlternatingSubarray(int[] nums, int threshold) {
        int temp = 0;
        for (int i = 0;i < nums.length;i++){
            if (nums[i] % 2 == 0 && nums[i] <= threshold){
                temp = Math.max(1,temp);
                for (int j = i+1;j<nums.length ; j++){
                    if (nums[j] <= threshold){
                        if ((j - i) % 2 == 1){
                            if (nums[j] % 2 != 1){
                                i = j-1;
                                break;
                            }
                        }else {
                            if (nums[j] % 2 != 0){
                                i = j-1;
                                break;
                            }
                        }
                        temp = Math.max(j-i+1,temp);
                    }else {
                        i = j-1;
                        break;
                    }
                }
            }
        }
        return temp;
    }

    //数位和相等数对的最大和
    public int maximumSum(int[] nums) {
        int result = -1;
        Map<Integer, PriorityQueue<Integer>> countMap = new HashMap<>();
        for (Integer num:nums){
            Integer count = getCount(num);
            //正常排序优先队列
            PriorityQueue<Integer> queue = countMap.getOrDefault(count, new PriorityQueue<>(Comparator.naturalOrder()));
            queue.offer(num);
            if (queue.size() > 2){
                queue.poll();
            }
            if (queue.size() == 2){
                Integer temp = queue.stream().reduce(0, Integer::sum);
                result = Math.max(temp,result);
            }
            countMap.put(count,queue);
        }
        return result;
    }

    //获取数位和
    private Integer getCount(Integer num){
        int count = 0;
        while (num != 0){
            count += (num % 10);
            num = num/10;
        }
        return count;
    }

    //最大子数组和
    public int maxSubArray(int[] nums) {
        int max = nums[0];
        int count = 0;
        for (int num:nums){
            if (count > 0){
                count += num;
            }else {
                count = num;
            }
            max = Math.max(max,count);
        }
        return max;
    }

    public static void main(String[] args) {
        Solution1120 test = new Solution1120();
        int[] temp = {3,2,5,4};
        int i = test.longestAlternatingSubarray(temp,5);
        System.out.println(i);
    }

}

